package controlador;
import java.util.Vector;
import vistas.*;
import negocio.*;

public class Negocio {
	
	public static Negocio miNegocio; 
	
	private Vector<Alumno> alumnos;
	private Vector<Materia> materias;
	private Vector<Profesor> profesores;
	private Vector<Curso> cursos;
	
	private Negocio() {
		super();
	}
	
	public static Negocio obtenerNegocio(){
		if (miNegocio == null){
			miNegocio = new Negocio();
		}
		return miNegocio;
	}
	
	public void agregarAlumno(AlumnoVO entradaAlumno){
		Alumno alu = new Alumno(entradaAlumno.getLegajo(), 
								entradaAlumno.getNombre(), 
								entradaAlumno.getEstado());
		this.alumnos.addElement(alu);
	}
	
	public void agregarMateria(MateriaVO entradaMateria){
		Materia mat = new Materia(entradaMateria.getNumero(),
								  entradaMateria.getNombre());
		this.materias.addElement(mat);
	}
	
	public void agregarProfesor(ProfesorVO entradaProfesor){
		Direccion dir = new Direccion(entradaProfesor.getDireccion().getCalle(),
								      entradaProfesor.getDireccion().getNumero(),
								      entradaProfesor.getDireccion().getCp(),
								      entradaProfesor.getDireccion().getLocalidad(),
								      entradaProfesor.getDireccion().getPiso(),
								      entradaProfesor.getDireccion().getDepartamento());
				
		Profesor prof = new Profesor(entradaProfesor.getNumeroLegajo(),
									 entradaProfesor.getNombre(),
									 dir);
		this.profesores.addElement(prof);
	}
	
	private Alumno alumnoPorLegajo(int legajo){
		Alumno salida = null;
		int tam = alumnos.size();
		while((tam > 0) && (salida != null)){
			if(alumnos.elementAt(tam-1).esTuLegajo(legajo))
				salida = alumnos.get(tam-1);
			else
				tam--;	
		}
		return salida;
	}
	
	public AlumnoVO obtenerAlumnoPorLegajo(AlumnoVO entradaAlumno) throws Exception {
		int legajo = entradaAlumno.getLegajo();
		Alumno alum = this.alumnoPorLegajo(legajo);
		return alum.getAlumnoVO();
		
	}
	
	private Curso cursoPorNumero(int numero){
		Curso salida = null;
		int tam = cursos.size();
		while((tam > 0) && (salida != null)){
			if(cursos.elementAt(tam-1).esTuNumero(numero))
				salida = cursos.get(tam-1);
			else
				tam--;	
		}
		return salida;
	}
	
	public CursoVO obtenerCursoPorNumero(CursoVO entradaCurso)  throws Exception {
		int num = entradaCurso.getNumeroCurso();
		Curso curso = this.cursoPorNumero(num);
		return curso.getCursoVO();
	}
	
	private Materia materiaPorNumero(String numero){
		Materia salida = null;
		int tam = materias.size();
		while((tam > 0) && (salida != null)){
			if(materias.elementAt(tam-1).esTuNumero(numero))
				salida = materias.get(tam-1);
			else
				tam--;	
		}
		return salida;
	}
	
	public MateriaVO obtenerMateriaPorNumero(MateriaVO entradaMateria){
		String nroMateria = entradaMateria.getNumero();
		Materia mat = this.materiaPorNumero(nroMateria);
		return mat.getMateriaVO();
	}
	
	private Profesor profesorPorLegajo(int numLegajo){
		Profesor salidaProfesor = null;
		int tam = profesores.size();
		while ((tam > 0) && (salidaProfesor != null)){
			if(profesores.get(tam-1).esTuLegajo(numLegajo))
				salidaProfesor = profesores.get(tam-1);
		}
		return salidaProfesor;
	}
	
	public ProfesorVO obtenerProfesorPorLegajo(ProfesorVO entradaProfesor){
		int numLegajo = entradaProfesor.getNumeroLegajo();
		Profesor prof = this.profesorPorLegajo(numLegajo);
		return prof.getProfesorVO();
	}
	
	public Vector<AlumnoVO> obtenerAlumnos(){
		Vector<AlumnoVO> alumnosVO = new Vector<AlumnoVO>();
			for(int i=0; i<alumnos.size(); i++)
				alumnosVO.addElement(alumnos.get(i).getAlumnoVO());
		return alumnosVO;
	}
	
	public Vector<CursoVO> obtenerCursos(){
		Vector<CursoVO> cursosVO = new Vector<CursoVO>();
			for(int i=0; i<cursos.size(); i++)
				cursosVO.addElement(cursos.get(i).getCursoVO());
		return cursosVO;
	}

	public Vector<MateriaVO> obtenerMaterias(){
		Vector<MateriaVO> materiasVO = new Vector<MateriaVO>();
			for(int i=0; i<materias.size(); i++)
				materiasVO.addElement(materias.get(i).getMateriaVO());
		return materiasVO;
	}

	public Vector<ProfesorVO> obtenerProfesores(){
		Vector<ProfesorVO> profesoresVO = new Vector<ProfesorVO>();
			for(int i=0; i<profesores.size(); i++)
				profesoresVO.addElement(profesores.get(i).getProfesorVO());
		return profesoresVO;
	}
	
	public void nuevoCurso(MateriaVO entradaMateria, ProfesorVO entradaProfesor, int cantMax){
		Materia resMateria = this.materiaPorNumero(entradaMateria.getNumero());
		Profesor resProfesor = this.profesorPorLegajo(entradaProfesor.getNumeroLegajo());
		Curso nuevo = new Curso(resMateria, resProfesor, cantMax);
		cursos.addElement(nuevo);
	}
	
	public void asignarMateriaProfesor(MateriaVO entradaMateria, ProfesorVO entradaProfesor){
		Materia mat = this.materiaPorNumero(entradaMateria.getNumero());
		Profesor prof = this.profesorPorLegajo(entradaProfesor.getNumeroLegajo());
		if((mat != null) && (prof != null)){
			prof.agregarMateria(mat);
		}
	}
	
	public void asignarAlumnoCurso(CursoVO entradaCurso, AlumnoVO entradaAlumno){
		Curso cur = this.cursoPorNumero(entradaCurso.getNumeroCurso());
		Alumno alu = this.alumnoPorLegajo(entradaAlumno.getLegajo());
		if((cur != null) && (alu != null)){
			cur.agregarAlumno(alu);
		}
	}
	
	public void eliminarAlumno(CursoVO entradaCurso, AlumnoVO entradaAlumno){
		Curso cur = this.cursoPorNumero(entradaCurso.getNumeroCurso());
		Alumno alu = this.alumnoPorLegajo(entradaAlumno.getLegajo());
		if((cur != null) && (alu != null)){
			cur.eliminarAlumno(alu);
		}
	}
}
